package cl.kts.dc.interfaces;


import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import cl.kts.dc.actor.ContadorActor;
import cl.kts.dc.actor.IndicadorPoderActor;
import cl.kts.dc.actor.MaloActor;
import cl.kts.dc.interfaces.Personaje.NivelesVelocidad;
import cl.kts.dc.util.Constantes;
import cl.kts.dc.util.Control;
import cl.kts.dc.util.CtrlTiempoJuegoTask;

import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.math.Rectangle;
import com.badlogic.gdx.scenes.scene2d.Stage;
import com.badlogic.gdx.utils.Scaling;
import com.badlogic.gdx.utils.Timer;
import com.badlogic.gdx.utils.viewport.ScalingViewport;

/**
 *
 * @author Francisco Garcia
 */
public abstract class Escenario extends Stage {

	private final Fondo fondo1, fondo2, fondo3, fondoprim;
	private final List<Objeto> objetosColisionables = new ArrayList<Objeto>();
	public final CtrlTiempoJuegoTask ctlTiempoJuegoTask;
	public Personaje personaje;
	private MaloActor maloActor;
	private final ContadorActor contador;
	private final IndicadorPoderActor indicadorVelocidad;

	public Escenario(Personaje personaje, Fondo fondo1, Fondo fondo2, Fondo fondo3, Fondo prim,
			int tiempoJuego) {
		super(new ScalingViewport(Scaling.stretch, Constantes.ANCHO_MAXIMO,
				Constantes.ALTO_MAXIMO, new OrthographicCamera(
						Constantes.ANCHO_MAXIMO, Constantes.ALTO_MAXIMO)));

		this.fondo1 = fondo1;
		this.fondo2 = fondo2;
		this.fondo3 = fondo3;
		this.fondoprim = prim;

		ctlTiempoJuegoTask = new CtrlTiempoJuegoTask(this, tiempoJuego);

		indicadorVelocidad = new IndicadorPoderActor(this);
		contador = new ContadorActor(this);
		this.personaje = personaje;
		maloActor = new MaloActor();

		addListener(new Control(personaje));
		addActor(maloActor);
		addActor(personaje);
		addActor(contador);
		addActor(indicadorVelocidad);

		Timer.schedule(ctlTiempoJuegoTask, 1, 1);
		Timer.schedule(new Timer.Task() {
			@Override
			public void run() {
				ejectuarLogica();
			}
		}, 1, 1);

		incremtarVelocidad(10);
	}

	private void verificarColisiones() {
		for (Objeto objetoColisionabe : objetosColisionables) {

			if (!objetoColisionabe.esColisionable) {
				continue;
			}
			Rectangle buenoActorRect = personaje.getContorno();
			Rectangle objRect = objetoColisionabe.getContorno();

			if (buenoActorRect.overlaps(objRect)) {
				objetoColisionabe.esColisionable = false;
				objetoColisionabe.realizarAnimacionChoque();

				if (objetoColisionabe.esObjetodePoder) {
					incrementarVelocidadJuego();

				} else {
					decrementarVelocidadJuego();
				}
			}
		}
	}

	private void incrementarVelocidadJuego() {

		if (personaje.nivelActualVel!=NivelesVelocidad.tres) {
			incremtarVelocidad(10);
		}
		personaje.incrementarVel();
		for (Objeto objeto : objetosColisionables) {
			objeto.incrementarVel();
		}
	}

	private void decrementarVelocidadJuego() {
		
		if (personaje.nivelActualVel!=NivelesVelocidad.uno) {
			incremtarVelocidad(-10);
		}

		personaje.caer();
		personaje.decrementarVel();

		for (Objeto objeto : objetosColisionables) {
			objeto.decrementarVel();
		}
	}

	private void verificarObjetosFuera() {
		for (Iterator<Objeto> itr = objetosColisionables.iterator(); itr
				.hasNext();) {
			Objeto objeto = itr.next();
			if (!objeto.esVisible()) {
				objeto.remove();
				itr.remove();
			}
		}
	}

	private void moverFondos() {
		fondo1.moverFondo();
		fondo2.moverFondo();
		fondo3.moverFondo();
		fondoprim.moverFondo();
	}

	public void incremtarVelocidad(int velocidad) {
		fondo1.setVelocidadIncremento(velocidad);
		fondo2.setVelocidadIncremento(velocidad);
		fondo3.setVelocidadIncremento(velocidad);
		fondoprim.setVelocidadIncremento(velocidad);
	}

	public void agregarObjetosColisionables(Objeto objetosColisionable) {
		addActor(objetosColisionable);
		objetosColisionables.add(objetosColisionable);
	}

	public void finalizarNivel() {
		// ctlTiempoJuegoTask.cancel();
	}

	@Override
	public void draw() {
		getBatch().begin();

		getBatch().draw(fondo1, 0, 0, fondo1.getVelocidad(), 0,
				Constantes.ANCHO_MAXIMO, Constantes.ALTO_MAXIMO);
		getBatch().draw(fondo2, 0, 0, fondo2.getVelocidad(), 0,
				Constantes.ANCHO_MAXIMO, Constantes.ALTO_MAXIMO);
		getBatch().draw(fondo3, 0, 0, fondo3.getVelocidad(), 0,
				Constantes.ANCHO_MAXIMO, Constantes.ALTO_MAXIMO);
		//
		// //super.draw();
		for (Objeto objeto : objetosColisionables) {
			objeto.draw(getBatch(), 0);
		}
		//
		personaje.draw(getBatch(), 0);
		maloActor.draw(getBatch(), 0);
		//
		// getBatch().draw(fondoprim, 0, 0, fondoprim.getVelocidad(), 0,
		// Constantes.ANCHO_MAXIMO, Constantes.ALTO_MAXIMO);
		contador.draw(getBatch(), 0);
		indicadorVelocidad.draw(getBatch(), 0);

		getBatch().end();

		moverFondos();
		verificarColisiones();
		verificarObjetosFuera();
	}

	public abstract void ejectuarLogica();
}
